/**
 * e-weaver
 * 
 * Copyright (c) 2011 Shanghai Weaver Software Co. Ltd.
 * 
 */
package com.sbtr.util;


import java.lang.reflect.Field;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 数字常用工具方法类
 */
public final class NumberHelper {
	public static String HEXSTRING="0123456789ABCDEF";
	private static final char[] hexCode = "0123456789ABCDEF".toCharArray();
    /**
     * 将输入的整数转成指定长度的字符串,不足的用0填充
     * @param iIn 需要填充0的整数

     * @param iLength 转换后的字符串的长度
     * @return 用0填充过的指定长度的字符串
     */
    public static String add0(int iIn, int iLength) {
        long lv = (long) Math.pow(10, iLength);
        if(lv < iIn)	return String.valueOf(iIn);
        return String.valueOf(lv + iIn).substring(1);
    }

    /**
     * 字符串转换为整数，转换异常返回-1。
     * @param strValue 字符串
     * @return 整数
     */
    public static int string2Int(String strValue) {
        return string2Int(strValue, -1);
    }

    /**
     * 字符串转换为整数，可设置转换异常默认值。
     * @param strValue 字符串
     * @param defValue 转换异常默认值
     * @return 整数
     */
    public static int string2Int(String strValue, int defValue) {
        try {
            return Integer.parseInt(strValue);
        } catch (Exception ex) {
            return defValue;
        }
    }
    
    /**
     * 对象转换为整数，可设置转换异常默认值。
     * @param obj 对象
     * @param defValue 转换异常默认值
     * @return 整数
     */
    public static int string2Int(Object obj, int defValue) {
    	if(obj==null){
    		return defValue;
    	}
        try {
            return Integer.parseInt(obj.toString());
        } catch (Exception ex) {
            return defValue;
        }
    }
    
    /**
     * 判断一个字符串（如11.0）是否为整数，是则返回整数，否则返回-1
     * @param strValue 字符串
     * @return
     */
    public static int string2Int2(String strValue) {
    	try {
    		if(StringHelper.isEmpty(strValue)){
    			return 0;
    		}
	    	Double dvalue = Double.valueOf(strValue); 
	    	int ivalue = dvalue.intValue();
	    	if(dvalue==ivalue){
	    	   return ivalue;
	    	}
    	}catch (Exception ex) {
            return -1;
        }
    	return -1;
    }

    /**
     * 判断一个字符串（11.0）是否为整数，是则返回整数，否则返回值

     * @param strValue
     * @return
     */
    public static int string2Int2(String strValue,int defValue) {
    	try {
    		if(strValue==null){
    			return 0;
    		}
	    	Double dvalue = Double.valueOf(strValue); 
	    	int ivalue = dvalue.intValue();
	    	if(dvalue==ivalue){
	    	   return ivalue;
	    	}
    	}catch (Exception ex) {
            return defValue;
        }
    	
    	return defValue;
    }
    
    /**
     * 对象转换为Integer对象，可设置转换异常返回值。
     * @param strValue 对象
     * @param defValue 转换异常返回值
     * @return 转换后Integer对象
     */
    public static Integer getIntegerValue(Object strValue, int defValue) {
        try {
            return Integer.valueOf(StringHelper.null2String(strValue));
        } catch (Exception ex) {
            return new Integer(defValue);
        }
    }

    /**
     * 对象转换为Integer对象，转换异常返回0。
     * @param strValue 对象
     * @return 转换后Integer对象
     */
    public static Integer getIntegerValue(Object strValue){
    	return getIntegerValue(strValue,0);
    }


    /**
     * 字符串转换为float对象，转换异常返回-1。
     * @param strValue 字符串
     * @return 转换后的float对象
     */
    public static float string2Float(String strValue) {
        return string2Float(strValue, -1);
    }


    /**
     * 字符串转换为float对象，可设置转换异常返回值。
     * @param strValue 字符串
     * @param defValue 转换异常返回值
     * @return 转换后的float对象
     */
    public static float string2Float(String strValue, float defValue) {
        try {
        	String changeValue=strValue.replace(",","");
            return Float.parseFloat(changeValue);
        } catch (Exception ex) {
            return defValue;
        }
    } 

    /**
     * 
     * @param strValue
     * @return
     */
    public static double string2Double(String strValue) {
        return string2Double(strValue, -1);
    }
    
    /**
     * 格式化金额每三位加逗号。
     * @param money double类型数字
     * @return
     */
    public static String moneyAddComma(double money) {
      return new DecimalFormat("#,##0.00").format(money);
    }
    
    /**
     * 格式化金额每三位加逗号。
     * @param money String类型
     * @return
     */
    public static String moneyAddComma(String money) {
      double tempmoney = string2Double(money,0);
      return new DecimalFormat("#,##0.00").format(tempmoney);
    }  
    
    /**
     * 格式化金额每三位加逗号。
     * @param money Object类型
     * @return
     */ 
    public static String moneyAddComma(Object money) {
      double tempmoney = string2Double(money,0);
      return new DecimalFormat("#,##0.00").format(tempmoney);
    }   
    
    /**
     * 格式化数据对象，显示指定的小数位
     * @param numStr 需要格式化的数据对象
     * @param digit 小数位
     * @return
     */
    public static String fixedDigits(Object numStr, int digit){
    	double tempNum = string2Double(numStr,0);

    	String s = String.format("%."+digit+"f",tempNum);
    	return s;
    }
    /**
     * 字符串转换为double类型，可设置转换异常默认值。
     * @param strValue 字符串
     * @param defValue 转换异常默认值
     * @return 转换后的double类型
     */
    public static double string2Double(String strValue, double defValue) {
        try {
        	if(strValue == null)
        		return defValue;
        	String changeValue=strValue.replace(",","");
            return Double.parseDouble(changeValue); 
        } catch (Exception ex) {
            return defValue;
        }
    }
    
    /**
     * 对象转换为double类型，可设置转换异常默认值。
     * @param obj 对象
     * @param defValue 转换异常默认值
     * @return 转换后的double类型
     */
    public static double string2Double(Object obj, double defValue) {
    	if(obj==null){
    		return defValue;
    	}
        try {
            return Double.parseDouble(obj.toString());
        } catch (Exception ex) {
            return defValue;
        }
    }

    /**
     * 获取随机数。
     * @param min 最小值
     * @param max 最大值
     * @return 生成的随机数
     */
    public static int getRandomInt(int min,int max){

    	Random random = new Random();
    	return Math.abs(random.nextInt()) % (max-min)+min;
    }

    /**
     * 浮点数四舍五入为整型。
     * @param fValue 浮点数
     * @return 四舍五入后的整数
     */
    public static int float2int(float fValue){
    	int intValue=(int)fValue;
    	float tFloat=fValue-intValue;
    	intValue=(int)(tFloat+fValue);
    	return intValue;
    }
    
    
    
    /**
     * 
     * @param num
     * @return
     */
    public static double fixDouble(double num){
    	return fixDouble(num,2);
    }
    
    /**
     * 
     * @param num
     * @param len
     * @return
     */
    public static double fixDouble(double num,int len){
    	if(len<0) len=2;
    	double n=Math.pow(10,len);
    	return (int)Math.floor(num*n)/n;
    }
    
    /**
     * t
     * @param num
     * @param len
     * @return
     */
    public static double fixDoubleCeil(double num,int len){
    	if(len<0) len=2;
    	double n=Math.pow(10, len);
    	return (int)Math.ceil(num*n)/n;
    }
    /**
     * 将两位16进制字符转换为byte
     * @param c1
     * @return
     */
    public static byte hexCharToByte(char c1,char c2){
    	
    	byte highByte=charToByte(c1);
    	byte lowByte=charToByte(c2);
    	byte retByte = (byte) ((highByte<<4)|lowByte);
    	return retByte;
    }
    /**
     * 将两位16进制字符串转换为byte
     * @param str
     * @return
     */
    public static byte hexStrToByte(String str){
    	if(str==null||str.length()!=2){
    		throw new NumberFormatException(
                    "str:" + str + "不是两位有效的16进制字符串！");
    	}
    	str = str.toUpperCase();
    	byte highByte=charToByte(str.charAt(0));
    	byte lowByte=charToByte(str.charAt(1));
    	byte retByte = (byte) ((highByte<<4)|lowByte);
    	return retByte;
    }
    
    public static byte charToByte(char c){
    	return (byte)HEXSTRING.indexOf(c);
    }
    /**
     * 将4位16进制字符串转换为short
     * @param b1 高字节
     * @param b2 低字节
     * @return
     */
    public static short twoByteToShort(byte b1,byte b2){
    	short hightByte = (short) (b1&0xFF);
    	short lowByte = (short) (b2&0xFF);
    	short retShort = (short) ((hightByte<<8)|lowByte);
    	return retShort;
    }
    
    /**
     * 将4位16进制字符串转换为short
     * @param str
     * @return
     */
    public static short hexStrToShort(String str){
    	if(str==null||str.length()!=4){
    		throw new NumberFormatException(
                    "str:" + str + "不是4位有效的16进制字符串！");
    	}
    	str = str.toUpperCase();
    	byte highByte1=charToByte(str.charAt(0));
    	byte lowByte1=charToByte(str.charAt(1));
    	byte highByte2=charToByte(str.charAt(2));
    	byte lowByte2=charToByte(str.charAt(3));
    	short hightByte = (short) (((highByte1<<4)|lowByte1)&0xFF);
    	short lowByte = (short) (((highByte2<<4)|lowByte2)&0xFF);
    	short retShort = (short) ((hightByte<<8)|lowByte);
    	return retShort;
    }
    
    /**
     * 根据两个数字类型的除数和被除数得到百分比
     * @param divisor
     * @param dividend
     * @return
     */
    public static Double getDivision(Object divisor,Object dividend){
    	//2：得到虚警率  虚警个数除以总故障数	;这里需要把虚警转为正数
    	
    	         String x = divisor.toString();
    	         String y = dividend.toString();
    			double number = Double.parseDouble(x)/Double.parseDouble(y);
    			DecimalFormat format = new DecimalFormat("0.0");
    			return Double.valueOf(format.format(number *100));//转换Double
    }
    /**
     * 将字节数据显示为16进制的字符串 每个字节之间以空格间隔
     * @param byteArr
     * @return
     */
    public static String byteArrToHexString(byte[] byteArr){
    	StringBuilder r = new StringBuilder(byteArr.length*3);
    	for(byte b:byteArr){
    		r.append(hexCode[(b>>4)&0xF]);
    		r.append(hexCode[b&0xF]);
    		r.append(" ");
    	}
    	return r.toString().trim();
    }
    
    public static byte[] hexStringToByteArr(String hexString){
    	hexString = hexString.replace("H", "").trim();
    	String[] strArr = hexString.split(" ");
    	byte[] byteArr = new byte[strArr.length];
		int i= 0;
		for(String str:strArr){
			byteArr[i]=hexStrToByte(str);
			i++;
		}
		return byteArr;
    }
    /**
     * 将字节数据显示为16进制的字符串 每个字节之间以空格间隔
     * @param b
     * @return
     */
    public static String byteToHexString(byte b){
    	StringBuilder r = new StringBuilder(2);
		r.append(hexCode[(b>>4)&0xF]);
		r.append(hexCode[b&0xF]);
    	return r.toString().trim();
    }
    
    /**
     * 计算概率；保存两位数
     * @param denominator  分母
     * @param numerator  分子
     * @return
     */
    public static String calcuteProbability(double numerator, double denominator){
	    DecimalFormat dFormat = new DecimalFormat("0.00");
	    if(denominator == 0)
	    	return "100";
	    
		String operating = dFormat.format(numerator/denominator*100);  // 利用率
		return operating;
    }
    
    /**
     * 保留几位小数,默认保留两位
     * @param number  // 要转换数字
     * @param decimal  // 几位小数
     * @return
     */
    public static String numberFormat(double number, int decimal){
    	String str = "0.";
    	if(decimal>1){
    		for(int i=0;i<decimal;i++){
    			str += "0";
    		}
    		
    	}else{
    		str = "0.00";
    	}
    	
	    DecimalFormat dFormat = new DecimalFormat(str);

		String value = dFormat.format(number); 
		return value;
    }

    /**
     * 计算一个对象多少属性不为空
     * @param obj
     * @return
     * @throws IllegalAccessException
     * @throws
     */
    public static Integer checkObjField(Object obj){
    	Integer number = 0;
    	for(Field f:obj.getClass().getDeclaredFields()){
    		f.setAccessible(true);
    		try {
				if(f.get(obj) != null && !f.get(obj).equals("")){
					++number;
				}
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
    	}
    	return number;
    }
    
    /**
     * 根据传入的对象，转换为数组
     * @param obj
     * @throws IllegalAccessException
     */
    public static Object[] getObjArrayByList(Object obj) throws IllegalAccessException{
    	
    	List<Object> list = new ArrayList<Object>();
    	for(Field f:obj.getClass().getDeclaredFields()){
    		f.setAccessible(true);
    		if(f.get(obj) != null && !f.get(obj).equals("")){
        		String result = (String) f.get(obj);
    			list.add(result);
    		}
    	}
        return (Object[]) list.toArray();
    }

	
}
